#pragma once

#define WIN32_LEAN_AND_MEAN    // 从 Windows 头文件中排除极少使用的内容

#include <stdio.h>
#include <memory>
#include <string>
#include <vector>
#include <map>
#include <windows.h>
#include <time.h>
using namespace std;

#ifdef  XC_MOUDLE

#endif

//@模块名称  基础模块  
//@版本  1.0  
//@日期  2020-10-23
//@作者  XCGUI  
//@模块备注 基础功能模块
// 字节集, 字符串操作, 编码转换, 内存操作, 
// 文件操作, 文件搜索, 
// 动态数组, 字典, 日期时间

//struct  mm;
//class CXText;
//class CXTextA;

#define   MAX_TEXT_1024     10240
extern char      g_convTemp[MAX_TEXT_1024];
extern wchar_t   g_convTempW[MAX_TEXT_1024];

/*@声明
#src "module_base.cpp"
*/

//@备注 文本操作类
//@别名 文本
class CXText
{
public:
	CXText() { _text = new wstring; }
	CXText(const CXText& _that) {
		if (_that._bMove) //数据所有权已被移走, 此处只是数据的副本, 所以复制数据
		{
			_text = new std::wstring;
			*_text = *_that._text;
		} else //获得数据所有权,避免不必要的数据复制
		{
			_text = _that._text;
			((CXText&)_that).move();
		}
	}
	CXText(const wstring &wstring_) { _text = new std::wstring;  *_text = wstring_; }
	CXText(const wchar_t* pText) { _text = new std::wstring; if (pText) *_text = pText; }
	~CXText() { if (!_bMove) delete _text; }
	void operator=(const wchar_t* pText) { *_text = pText ? pText : L""; }
	void operator=(const wstring &wstring_) { *_text = wstring_; }
	bool operator==(const wchar_t* pText) const { return (*_text == pText); }
	bool operator<(const CXText &_right) const { return (_text->compare(*_right._text) < 0); }
	operator const wchar_t*() const {return(_text->c_str()); }//当作为函数参数传递时, 自动转换为[const char*]
	//@别名  取地址()
	const wchar_t*  toStr() const { return (wchar_t*)_text->c_str(); }
	//@别名 大小()
	int  size() { return _text->size(); }
	void resize(UINT length) { _text->resize(length); };
private:
	//move()移出数据所有权, 当所有权被移除后,析构时保留数据, 
	//如果 _bMove=TRUE 数据所有权已被移走, 析构时不需要销毁数据
	//如果 _bMove=FALSE 持有数据所有权, 析构时销毁数据
	//与智能指针不同, 没有引用计数, 只有持有所有权的对象销毁时 才销毁数据,其他对象只是对数据的引用
	//当对象赋值时, 自动调用此方法, 移交所有权
	//例如:
	//CXText textA = "123";
	//CXText textB = textA;  //自动调用move()函数移动所有权, 如果textA没有所有权,只是一个副本, 那么仅复制数据
	//此方法的作用减少内存的复制, 当 textA 赋值给 textB时, 仅是把数据指针赋值给B,并不会复制数据, 减少内存复制带来的开销
	void move() { _bMove = TRUE; }
	std::wstring*  _text;
	BOOL   _bMove;
};

//@备注 文本操作类A
//@别名 文本A
class CXTextA
{
public:
	CXTextA() { }
	CXTextA(const CXTextA& _that) {
		if (_that._bMove) //数据所有权已被移走, 此处只是数据的副本, 所以复制数据
		{
			_text = new std::string;
			*_text = *_that._text;
		} else //获得数据所有权,避免不必要的数据复制
		{
			_text = _that._text;
			((CXTextA&)_that).move();
		}
	}
	CXTextA(const string &string_) { _text = new std::string; *_text = string_; }
	CXTextA(const char* pText) { _text = new std::string; if (pText) *_text = pText; }

	void operator=(const char* pText) { *_text = pText ? pText : ""; }
	void operator=(const string &string_) { *_text = string_; }
	bool operator==(const char* pText) const { return (*_text == pText); }
	bool operator<(const CXTextA &_right) const { return (_text->compare(*_right._text) < 0); }
	operator const char*() const { return(_text->c_str()); } //当作为函数参数传递时, 自动转换为[const char*]
	//@别名  取地址()
	const char*  toStr() const { return _text->c_str(); }
	//@别名 大小()
	int  size() { return _text->size(); }
	void resize(UINT length) { _text->resize(length); };
	void move() { _bMove = TRUE; } //析构时保留数据
private:
	std::string*  _text;
	BOOL   _bMove;
};

static bool operator==(const wchar_t* left, CXText& right)
{
	return right == left;
}

static bool operator==(const char* left, CXTextA& right)
{
	return right == left;
}

#include "xc_log.h"
#include "xc_logA.h"

//@别名  组合文本()
wchar_t*  mkStr(...);


//@别名  调试输出()
void xc_log(...);

//@别名  调试输出A()
void xc_logA(...);

//@隐藏{
//----------mkStr-------------------------
template<class T>
wstring  mkStr(T t)
{
	wstring strText;
	mkValue(strText, t);
	return strText;
}

template<class T1, class T2>
wstring  mkStr(T1 t1, T2 t2)
{
	wstring strText;
	mkValue(strText, t1);
	mkValue(strText, t2);
	return strText;
}

template<class T1, class T2, class T3>
wstring  mkStr(T1 t1, T2 t2, T3 t3)
{
	wstring strText;
	mkValue(strText, t1);
	mkValue(strText, t2);
	mkValue(strText, t3);
	return strText;
}

template<class T1, class T2, class T3, class T4>
wstring  mkStr(T1 t1, T2 t2, T3 t3, T4 t4)
{
	wstring strText;
	mkValue(strText, t1);
	mkValue(strText, t2);
	mkValue(strText, t3);
	mkValue(strText, t4);
	return strText;
}

template<class T1, class T2, class T3, class T4, class T5>
wstring  mkStr(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
{
	wstring strText;
	mkValue(strText, t1);
	mkValue(strText, t2);
	mkValue(strText, t3);
	mkValue(strText, t4);
	mkValue(strText, t5);
	return strText;
}

template<class T1, class T2, class T3, class T4, class T5, class T6>
wstring  mkStr(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
{
	wstring strText;
	mkValue(strText, t1);
	mkValue(strText, t2);
	mkValue(strText, t3);
	mkValue(strText, t4);
	mkValue(strText, t5);
	mkValue(strText, t6);
	return strText;
}

template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
wstring  mkStr(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
{
	wstring strText;
	mkValue(strText, t1);
	mkValue(strText, t2);
	mkValue(strText, t3);
	mkValue(strText, t4);
	mkValue(strText, t5);
	mkValue(strText, t6);
	mkValue(strText, t7);
	return strText;
}

template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
wstring  mkStr(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
{
	wstring strText;
	mkValue(strText, t1);
	mkValue(strText, t2);
	mkValue(strText, t3);
	mkValue(strText, t4);
	mkValue(strText, t5);
	mkValue(strText, t6);
	mkValue(strText, t7);
	mkValue(strText, t8);
	return strText;
}

template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
wstring  mkStr(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
{
	wstring strText;
	mkValue(strText, t1);
	mkValue(strText, t2);
	mkValue(strText, t3);
	mkValue(strText, t4);
	mkValue(strText, t5);
	mkValue(strText, t6);
	mkValue(strText, t7);
	mkValue(strText, t8);
	mkValue(strText, t9);
	return strText;
}
//@隐藏}

//----------CXBytes------------------------------------------
//@别名 字节集
class CXBytes
{
	char*   _data;
	int     _length;
	BOOL    _bMove;
public:
	CXBytes();
	CXBytes(const CXBytes& bytes);
	~CXBytes();
	void operator=(const CXBytes &bytes);

	char* Alloc(UINT length);
	void  Clear() { free(_data); }
	const char* get()  { return _data; }
	const wchar_t*  getW() { return (wchar_t*)_data; }
	int   size() { return _length; }
	void  move() { _bMove = TRUE; } //析构时保存内存数据
};

//@别名 文件类
class CXFile
{
	FILE*  m_file;
public:
	CXFile();

	BOOL open(const wchar_t* pFileName);      //读写模式
	BOOL openRead(const wchar_t* pFileName);  //只读模式
	BOOL openWrite(const wchar_t* pFileName);   //打开空文件写入
	BOOL openEx(const wchar_t* pFileName, const wchar_t* pMode); //扩展
	void close();
	UINT getLength(); //获取文件长度
	BOOL seekBegin(); //移动到文件首
	BOOL seekEnd(); //移动到文件尾
	BOOL seekPos(int offset, int origin); //移动读写位置

	UINT readData(void* data, int nLength);    //取数据
	BOOL readDataRow(char* data, int nLength);  //取一行文本
	CXBytes readDataBytes(int nLength=-1); //读取数据到字节集

	BOOL writeData(const void* data, int nLength); //写入数据
	BOOL writeText(const wchar_t* data, int nLength=-1);
	BOOL writeTextA(const char* data, int nLength=-1);
};
//复制文件
//创建文件
//创建文件夹

//@分组{   文件处理

//创建文件夹及子文件夹,如果文件夹不存在
BOOL createFolders(const wchar_t*  pPath);

//复制文件自动创建路径
BOOL copyFile(const wchar_t* dest, const wchar_t*  src);

//@分组}

//--------------------------------
//@分组{   编码转换
CXText utf8ToW(const char *utf8, int length=-1);
CXBytes wToUtf8(const wchar_t *pString, int length=-1);

CXTextA W2A(const wchar_t* pString, int length=-1);
CXText  A2W(const char* pString, int length=-1);

const char* W2A_temp(const wchar_t* pString);
const wchar_t*  A2W_temp(const char* pString);
//@分组}


//----------------------
//@分组{  文本操作
/*@声明
errno_t strcpy_s(char *strDestination,size_t numberOfElements,const char *strSource);
errno_t wcscpy_s(wchar_t *strDestination,size_t numberOfElements,const wchar_t *strSource);

char *strstr(const char *str,const char *strSearch);
wchar_t *wcsstr(const wchar_t *str,const wchar_t *strSearch);

errno_t strcat_s(char *strDestination,size_t numberOfElements,const char *strSource);
errno_t wcscat_s(wchar_t *strDestination,size_t numberOfElements,const wchar_t *strSource);

UINT strlen(const char *str);
UINT wcslen(const wchar_t *str);

*/
//@分组}

//@分组{  文件查找

/*@声明
struct FILETIME {
	DWORD  dwLowDateTime;
	DWORD  dwHighDateTime;
};

struct WIN32_FIND_DATA {
	DWORD   dwFileAttributes;
	FILETIME   ftCreationTime;
	FILETIME   ftLastAccessTime;
	FILETIME   ftLastWriteTime;
	DWORD    nFileSizeHigh;
	DWORD    nFileSizeLow;
	DWORD    dwReserved0;
	DWORD    dwReserved1;
	WCHAR    cFileName[MAX_PATH];
	WCHAR    cAlternateFileName[14];
	DWORD    dwFileType;
	DWORD    dwCreatorType;
	WORD     wFinderFlags;
};

HANDLE WINAPI FindFirstFile(const wchar_t* lpFileName, WIN32_FIND_DATA* lpFindFileData);
BOOL WINAPI FindNextFileA(HANDLE hFindFile,WIN32_FIND_DATA* lpFindFileData);
*/

//@分组}


//@分组{ 内存操作
/*@声明
void *memcpy(void *dest,const void *src,size_t count);
wchar_t *wmemcpy(wchar_t *dest,const wchar_t *src,size_t count);

int memcmp(const void *buf1,const void *buf2,size_t count);
int wmemcmp(const wchar_t * buf1,const wchar_t * buf2,size_t count);

void *malloc(size_t size);
void free(void *memblock);
*/

//@分组}


//@分组{  日期时间

/*@声明
time_t time(time_t *timer);
tm *localtime(const time_t *timer);
DWORD GetTickCount();
*/
//@备注  获取当时间 例如: [2020-10-29  12:05:03]
const wchar_t*  GetTime_temp();

//@分组}


//---------vector---------------------------------------
/*@声明

//@别名 动态数组
class vector
{
	//@别名 大小()
	int size();

	//@别名 添加项()
	迭代器 push_back();

	//@别名 第一个()
	迭代器 begin();

	//@别名 空值()
	迭代器 end();

	//@别名 是否为空()
	布尔型 empty();

	//@别名 删除()
	迭代器 erase(...);

	//@别名  清空()
	无返回 clear();
};

//-------------map-------------------------------------
//@别名 迭代器
class iterator
{
	//@别名  键
	void first;

	//@别名  值
	void second;
};

//@别名 字典
class map
{
	//@别名 大小()
	int size();

	//@别名 查找()
	迭代器 find();

	//@别名 第一个()
	迭代器 begin();

	//@别名 空值()
	迭代器 end();

	//@别名 是否为空()
	布尔型 empty();

	//@别名 删除()
	迭代器 erase(...);

	//@别名  清空()
	void clear();
};
*/

//数据库
//网络库
//浏览器
//常用系统API
